 /*--------------------- 封装过程中的对比测试-------*/
 function test(resolve, reject) {
    // resolve('成功'); // 同步成功测试
    // reject('失败'); // 同步失败测试
    // 异步测试
    setTimeout(() => {
        var count = 1;
        if (count === 1) {
            resolve('成功');
        } else {
            reject('失败');
        }
    }, 1000);
}

function test1(resolve, reject) {
    // resolve('成功'); // 同步成功测试
    // reject('失败'); // 同步失败测试
    // 异步测试
    setTimeout(() => {
        var count = 1;
        if (count === 1) {
            resolve('成功1111');
        } else {
            reject('失败');
        }
    }, 3000);
}
function test2(resolve, reject) {
    // resolve('成功'); // 同步成功测试
    // reject('失败'); // 同步失败测试
    // 异步测试
    setTimeout(() => {
        var count = 1;
        if (count === 1) {
            resolve('成功1111');
        } else {
            reject('失败');
        }
    }, 5000);
}
// var promise = new Promise(test).then((res) => {
//     console.log(res, 'promise');
// }).catch(res => {
//     console.log(res, 'promise');
// }).finally(() => {
//     console.log(13131313);
// });
var a = Promise.all([new Promise(test1), new Promise(test), 222, undefined]).then(res => {
    console.log(res, '----------++++++++++++');
});

/** ------------------------------------------------ 原生js封装Promise */

function MyPromise(callback) {
    this.status = 'pending'; // promise的三种状态
    this.successMsg = ''; // 成功的信息
    this.errorMsg = ''; // 失败的信息
    this.successArr = []; // 成功的数组
    this.errorArr = []; // 失败的数组
    this.allArr = []; // 不论成功或失败的数组
    if (typeof callback === 'function') {
        callback((res) => {
            if (this.status === 'pending') {
                this.status = 'fulfilled'; // 成功状态
                this.successMsg = res;
                this.successArr.forEach(v => v(res)); // 运行这里面的数据
                this.allArr.forEach(v => v()); // 运行这里面的数据
            }
        }, (err) => {
            if (this.status === 'pending') {
                this.status = 'rejected'; // 失败状态
                this.errorMsg = err;
                this.errorArr.forEach(v => v(err)); // 运行这里面的数据
                this.allArr.forEach(v => v()); // 运行这里面的数据
            }
        });
    }
    return this;
}

/* ----------------- all的封装*/
MyPromise.all = arr => {
    var result = new Array(arr.length); // 用于存放每次执行后返回结果
    return new MyPromise((resolve, reject) => {
        if (Array.isArray(arr)) {
            arr.forEach((item, index) => {
                if (item && typeof item === 'object') {
                    // 这里判断是否为promise
                    item.then(res => {
                        result[index] = res; // 保持数据位置不变
                        resolveData(result);
                    }, err => {
                        reject(err);
                    });
                } else {
                    result[index] = item; // 保持数据位置不变
                    resolveData(result);
                }
            });
        }
       // 判断返回数据
        function resolveData(arr) {
            var count = 0;
            arr.forEach(item => {
                // 判断数据中有没有empty
                if (++count === arr.length) {
                    resolve(arr);
                }
            })
        }
    })
}

/* -----------    then方法的封装 */
MyPromise.prototype.then = function (success, error) {
    var successFlag = typeof success === 'function';
    var errorFlag = typeof error === 'function';
    if (this.status === 'pending') {
        // 这里是异步处理
        successFlag && this.successArr.push(success); // 将成功的回调加进成功的数组
        errorFlag && this.errorArr.push(error); // 将失败的回调加进失败的数组
    } else if (this.status === 'fulfilled') {
        // 同步处理成功
        successFlag && success(this.successMsg);
        return this;
    } else if (this.status === 'rejected') {
        // 同步处理失败
        errorFlag && error(this.errorMsg); // 直接执行
    }
    return this;
}
/* ---------catch的封装*/
MyPromise.prototype.catch = function (error) {
    var flag = typeof error === 'function';
    if (this.status === 'pending') {
        // 这里是异步处理
        flag && this.errorArr.push(error); // 将失败的回调加进失败的数组
    } else if (this.status === 'rejected') {
        // 同步处理
        flag && error(this.errorMsg); // 直接执行
    }
    return this;
}
/* ---------finally的封装*/
MyPromise.prototype.finally = function (res) {
    var flag = typeof res === 'function';
    if (this.status === 'pending') {
        // 这里是异步处理
        flag && this.errorArr.push(res); // 将回调放入数组
    } else {
        // 同步处理
        flag && res(); // 直接执行
    }
    return this;
}


/*-------------------------- 测试MyPromise */

// var promise1 = new MyPromise(test).then(res => {
//     console.log(res,'myPromise');
// },err=>console.log(err,'myPromise')).catch(err=>{
//     console.log(err,'catch');
// }).finally(()=>{
//     console.log(13131313);
// });
var a = MyPromise.all([new Promise(test1), new Promise(test), 222,undefined,null,new Promise(test2)]).then(res => {
    console.log(res, '----------');
}, (err) => {
    console.log(err);
});